package internal

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"strings"
)

func bindata_read(data []byte, name string) ([]byte, error) {
	gz, err := gzip.NewReader(bytes.NewBuffer(data))
	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}

	var buf bytes.Buffer
	_, err = io.Copy(&buf, gz)
	gz.Close()

	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}

	return buf.Bytes(), nil
}

var _internal_internal_go = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00")

func internal_internal_go() ([]byte, error) {
	return bindata_read(
		_internal_internal_go,
		"internal/internal.go",
	)
}

var _internal_internal_gs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x56\xbd\x6e\x1b\x47\x17\xed\xf9\x14\xf7\x13\xf0\x19\x4b\x88\x20\xe3\x26\x29\x84\x2d\x12\xc7\xb6\x60\xc8\x76\x22\x19\x69\x04\x15\x63\xee\x25\x77\xcc\xe5\xec\x6a\xe6\xee\x5a\x14\x41\x20\x48\xaa\x54\x06\x12\xe4\x01\x02\xa4\x48\x9a\x34\x49\x93\x26\x6f\x23\xc1\x79\x8b\xe0\xce\xcc\x72\x67\x7f\x04\xc1\xa9\xa2\x42\xe0\xee\x9c\x7b\xce\x99\x3b\x67\x66\x76\x36\x03\x8d\x54\x6a\x05\x42\x6b\xb1\x81\x0c\xd5\x92\xd2\x91\x54\xc4\x3f\x23\xa1\x36\xe7\x17\x20\xc6\xdb\xdd\x68\xd4\x40\x53\x61\xd2\x79\x9e\xa0\x85\xf1\x03\xe3\xc0\x58\x54\xa1\xa5\xa2\x4c\x45\xbe\x64\x91\xeb\xb5\x20\x03\x62\x3e\xcf\x75\x22\xd5\x12\x28\x07\x01\xee\x35\x98\x02\xe7\x72\x21\x51\x83\x50\x09\xbc\xd5\x92\xd0\x30\xc0\x90\x50\x89\xd0\x09\xe4\x25\x15\x25\x4d\x1d\xeb\x22\x32\xa4\x99\xc2\x55\x4f\x80\x55\xa7\xd3\xa9\xf8\x17\x5a\x6e\x26\x06\x28\x45\xd0\x68\xca\x8c\x18\xef\xf8\xa7\x23\xaf\x63\xee\x97\x15\xc6\xa0\xa6\xc7\x97\xa5\xc8\xec\x94\x45\x51\xa0\x4a\xea\xd9\xc3\xe7\x82\xb0\x66\x5b\x22\x3d\x2a\xb5\x46\x45\xaf\xe4\x1a\x6b\x52\xba\x9e\x78\x59\xc8\xc4\x26\x2f\xa9\x2e\x7d\x8a\x04\xb9\x01\xa1\x97\xa6\x36\x74\x7e\xc1\x24\x2f\xcf\x3e\xd5\x4b\x13\x75\xd6\xe4\xd9\xd9\xcb\x17\x9e\xa8\x16\xe4\x57\x76\x65\xac\xd3\xd9\xcc\x61\x2e\x4b\xd4\x1b\x78\x2b\x29\x85\x42\x50\x3a\x62\x00\x0f\x3c\x45\xaa\x3d\xbd\x31\xb9\xda\xbb\x62\x90\xd5\x62\x86\x94\xa8\x80\x4c\xbe\xe6\xdf\xa7\x68\x8a\x5c\x19\xb4\xf0\xd1\x13\xd7\x2b\xab\xc9\xb1\xe0\x7c\xb4\x38\xf6\x0f\x0c\xf7\x86\x4e\xd1\x58\x86\x94\xd6\x59\xcd\x70\xfc\xea\xf9\xc9\x3d\x0c\x0c\xaf\xa7\xcf\x03\x10\x69\xcc\x04\xc9\x0a\xed\xa3\x81\xb5\xd8\x40\xbe\x96\x9c\x61\x61\x83\x60\x32\x61\xd2\x71\xdd\x98\x2f\xb9\x05\x5f\x08\x4a\xa3\xee\x1c\xfd\xf3\x93\x5c\xaf\xbf\x12\x59\x89\xd1\x90\xfc\x0a\x37\x0c\x9e\x67\xc2\x18\x38\x26\x2a\x1e\xe5\x8a\xf0\x8a\xb6\x23\x00\x08\x0d\x1f\xd9\x17\x9d\x96\x70\xbf\xab\xb1\xc3\x06\x78\xee\x0a\xc4\x0e\x5c\x8d\x8f\xf6\xc3\x61\x5f\x1d\x81\xf3\x62\xbb\xe8\x60\x3b\xfb\xbf\xd3\x37\x27\x03\x3d\x1d\xee\x1d\xc4\x50\xf5\x14\x6c\x7d\xa8\x60\xbb\x1c\x2a\x78\x86\xcb\x7d\xf7\x06\xe8\x0b\x88\x83\xf6\xda\xbe\x36\x4a\x3e\xaa\x45\x4d\x1a\xb2\x2e\xba\x2d\xb7\x5d\xee\xd2\x57\x10\x07\x8b\xe3\x7c\x32\xb0\xa7\x51\xd5\x1a\x36\x67\x9f\x49\xde\xf2\x79\x49\x38\xe2\x04\x1f\x0b\x95\x64\x7b\xa1\x35\x52\x9a\x27\x9d\xa4\x2d\x4a\x35\x87\x28\x58\xdc\x31\xa4\xb6\xca\x7b\xe2\xe4\xf9\x93\xee\x80\x2b\xe2\x83\xc3\x60\xb2\x41\x1d\xcc\xe9\x0a\xe2\xf0\x4d\xe4\x41\x8e\x2f\x9a\xd3\xd5\xf8\xc8\xd9\x3c\x2d\x95\xdb\x61\x06\x75\x85\x7a\x6a\xcd\x9e\x96\xaa\x76\x2a\x92\x44\xdb\x98\xba\xe8\x3d\x56\xa4\x37\xce\x0e\xaf\xf6\x0a\x37\x93\x8a\xfb\xe2\xe8\xed\x28\x28\xbc\xa2\xe0\xd9\x1e\x07\x2b\x9f\x8e\x49\x8d\x09\xfa\xbc\xc2\x4d\xbc\x6a\xba\x69\xf9\xe2\x20\x2c\xcc\x17\xab\xa6\xb9\xce\xc9\x73\x51\x6c\x1b\x91\xf3\x0b\x20\xf1\x3a\x43\x88\xe1\xfc\xe1\xc7\x17\xdb\x9d\x83\x73\x36\x8d\xbc\xc6\xf8\xa3\x23\xb7\xf2\x45\x49\x51\x6d\xdc\x39\x62\xb5\xc0\xcc\x6c\x06\x94\x27\x39\xcc\x75\x6e\x4c\x5e\xa1\x7e\x26\x11\x6e\xbf\xfb\xf5\xe6\xb7\x3f\xf7\x18\xb9\x88\xd8\x73\x7c\x70\x10\x14\x36\x41\x68\x9c\xef\x9a\x12\x7f\x6b\x71\xd8\x21\x76\x17\x58\x3b\x44\x8c\x90\x7e\xc8\xa2\xfe\x6f\x6f\x43\x3b\xab\x31\x34\x38\xd7\x3f\x26\xb1\x43\xe7\xf2\x22\xe0\x58\x40\x84\xf0\xbf\x18\x94\xcc\x3a\xd6\x5c\x19\xe1\xba\x70\xbf\x62\xc0\xa3\x16\x60\x91\x6b\x88\x9a\x71\x4f\x02\x6d\x96\xda\xe8\xdc\x5d\x2a\xc7\xc2\xa4\xf5\x6c\xf6\xa5\xd3\xf6\xbc\x42\x6f\xad\xb2\x60\xaa\x0f\x1e\xf0\x82\xf0\xab\x36\x4b\x5f\x9c\xff\x1a\x8c\x8b\x0a\x04\x09\xec\xfe\x75\x57\xa4\xbf\x32\x3d\x56\x08\x5d\x34\x59\x1e\xae\xac\xd7\x00\x62\x1f\x76\x1b\x2c\x6b\x68\x02\xd8\x69\x03\x27\xf1\xf0\xd0\x27\xd1\x72\x01\x66\x06\x3b\x3d\x9e\xcd\xe0\xe6\xdd\x37\xef\xbf\xfe\x16\xde\x24\xab\x87\xd3\x4f\xe0\xef\x1f\xfe\x7a\xff\xd3\x2f\x37\x3f\xff\x71\xfb\xee\xfb\xdb\xdf\x7f\xbc\x5f\xdf\xc9\xf3\xf2\x0d\xeb\x37\x53\x09\x0f\x45\xde\x0d\x4b\xdc\x6f\x8f\xa0\xf9\xff\xd9\xbc\xdb\xcc\xa2\x5d\xa4\xe1\xd4\xdf\x91\x55\x1c\xc8\x28\xe7\xd3\x87\xd0\x0e\x73\x28\xef\xc8\xeb\x40\x2e\xfd\x15\x80\xd3\x81\x2c\xb6\x13\xc3\x33\xc1\x4e\xae\x76\xad\x1d\x1c\x58\x6c\xed\x92\x60\x9b\xe0\xc0\xf6\xb8\xcb\xc2\x6e\x20\x63\x1e\xab\x64\xd6\x35\xe1\xc3\xc0\x8d\x5b\x22\x9d\xc9\x6b\x8c\x02\x1d\x5f\xc7\x41\x6a\xce\x63\xfb\x4d\x74\x22\xd5\x0a\x93\x13\x69\xc8\x9f\xcf\xee\xc5\x8b\x3c\xc1\xe6\xba\x08\x9c\x35\xc3\xc1\x7d\xd1\xbc\x8c\xba\x9f\x2c\xb6\xb4\xfd\x11\x61\x97\x3d\x86\xde\xcd\xd0\x58\xd9\x76\xa5\x16\x52\x1b\x9a\x40\x26\x0c\xdd\x71\x41\x88\x24\xe9\x69\xf3\xa2\x54\xdc\xf6\x0f\xd8\x00\x81\x28\x7f\xfb\x04\x33\x0b\xbf\xb4\x98\xd9\x7a\x62\xf6\x7e\x7c\xfd\x10\x64\xed\x40\xb1\xfd\xf6\x5b\x77\x90\x6c\x7b\xa8\xa9\xef\xd1\xfd\x04\xbd\x83\x02\x06\x4e\x8a\xa4\x5c\x17\x61\x1c\x82\x49\x1a\x12\x9a\x39\xad\xe5\xce\x0e\x75\x63\x83\x1b\xb4\xfe\xa0\xb1\x10\x97\xdc\xee\xa1\xe5\x89\x1d\x62\x68\xdf\x7c\x78\x64\xff\x09\x00\x00\xff\xff\x33\x24\x32\xc4\x82\x0e\x00\x00")

func internal_internal_gs() ([]byte, error) {
	return bindata_read(
		_internal_internal_gs,
		"internal/internal.gs",
	)
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		return f()
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() ([]byte, error){
	"internal/internal.go": internal_internal_go,
	"internal/internal.gs": internal_internal_gs,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for name := range node.Children {
		rv = append(rv, name)
	}
	return rv, nil
}

type _bintree_t struct {
	Func     func() ([]byte, error)
	Children map[string]*_bintree_t
}

var _bintree = &_bintree_t{nil, map[string]*_bintree_t{
	"internal": &_bintree_t{nil, map[string]*_bintree_t{
		"internal.go": &_bintree_t{internal_internal_go, map[string]*_bintree_t{}},
		"internal.gs": &_bintree_t{internal_internal_gs, map[string]*_bintree_t{}},
	}},
}}
